#!/bin/bash

# =========================================================
# Agent 启动脚本 - 人性化版本
# 功能：
#   1. 环境检查（Python版本、简单依赖）
#   2. 虚拟环境检查和创建
#   3. 依赖安装
#   4. 直接运行或安装为系统服务
# =========================================================

# 注意：不使用 set -e，因为某些检查失败时我们需要显示友好的错误信息

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# 配置
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
VENV_PATH="/opt/envs/playenv"
MIN_PYTHON_VERSION="3.10"  # 最低Python版本要求（根据代码兼容性：使用asyncio、match/case需要3.10+）
SERVICE_NAME="goofish-agent"
SERVICE_FILE="/etc/systemd/system/${SERVICE_NAME}.service"
PYTHON_CMD="python3"
PIP_CMD="pip3"

# 显示帮助信息
show_help() {
    echo -e "${CYAN}=========================================================${NC}"
    echo -e "${GREEN}  Goofish Agent 启动脚本${NC}"
    echo -e "${CYAN}=========================================================${NC}"
    echo ""
    echo "用法:"
    echo "  $0              # 直接运行Agent"
    echo "  $0 -i|--install # 安装为系统服务并开机启动"
    echo "  $0 -u|--uninstall # 停止并卸载系统服务"
    echo "  $0 -h|--help    # 显示帮助信息"
    echo ""
}

# 检查是否为root用户（仅安装服务时需要）
check_root() {
    if [ "$EUID" -ne 0 ]; then
        echo -e "${RED}❌ 安装/卸载服务需要root权限，请使用: sudo $0 $@${NC}"
        exit 1
    fi
}

# 检查Python版本
check_python_version() {
    echo -e "${YELLOW}🔍 检查Python版本...${NC}"
    
    # 检查Python是否安装
    if ! command -v python3 &> /dev/null && ! command -v python &> /dev/null; then
        echo -e "${RED}❌ Python未安装！${NC}"
        echo -e "${YELLOW}⚠️  请运行以下命令进行完整环境安装：${NC}"
        echo -e "${CYAN}   bash setup_ubuntu.sh${NC}"
        exit 1
    fi
    
    # 确定Python命令
    if command -v python3 &> /dev/null; then
        PYTHON_CMD="python3"
        PIP_CMD="pip3"
    elif command -v python &> /dev/null; then
        PYTHON_CMD="python"
        PIP_CMD="pip"
    fi
    
    # 获取Python版本
    PYTHON_VERSION=$($PYTHON_CMD --version 2>&1 | awk '{print $2}')
    PYTHON_MAJOR=$(echo $PYTHON_VERSION | cut -d. -f1)
    PYTHON_MINOR=$(echo $PYTHON_VERSION | cut -d. -f2)
    
    # 检查版本是否满足要求
    MIN_MAJOR=$(echo $MIN_PYTHON_VERSION | cut -d. -f1)
    MIN_MINOR=$(echo $MIN_PYTHON_VERSION | cut -d. -f2)
    
    # 版本比较（纯bash实现）
    VERSION_CHECK=0
    if [ "$PYTHON_MAJOR" -lt "$MIN_MAJOR" ]; then
        VERSION_CHECK=1
    elif [ "$PYTHON_MAJOR" -eq "$MIN_MAJOR" ] && [ "$PYTHON_MINOR" -lt "$MIN_MINOR" ]; then
        VERSION_CHECK=1
    fi
    
    if [ "$VERSION_CHECK" -eq 1 ]; then
        echo -e "${RED}❌ Python版本过低: $PYTHON_VERSION${NC}"
        echo -e "${YELLOW}⚠️  最低要求: Python $MIN_PYTHON_VERSION${NC}"
        echo -e "${YELLOW}⚠️  请运行以下命令进行完整环境安装：${NC}"
        echo -e "${CYAN}   bash setup_ubuntu.sh${NC}"
        exit 1
    fi
    
    echo -e "${GREEN}✅ Python版本: $PYTHON_VERSION${NC}"
}

# 检查并安装简单依赖（xvfb等）
check_and_install_simple_deps() {
    echo -e "${YELLOW}🔍 检查简单依赖...${NC}"
    
    # 检查Xvfb（xvfb-run需要Xvfb）
    if ! command -v Xvfb &> /dev/null; then
        echo -e "${YELLOW}📦 安装Xvfb...${NC}"
        if command -v apt-get &> /dev/null; then
            sudo DEBIAN_FRONTEND=noninteractive apt-get install -y xvfb > /dev/null 2>&1
        elif command -v yum &> /dev/null; then
            sudo yum install -y xorg-x11-server-Xvfb > /dev/null 2>&1
        elif command -v dnf &> /dev/null; then
            sudo dnf install -y xorg-x11-server-Xvfb > /dev/null 2>&1
        else
            echo -e "${RED}❌ 无法自动安装Xvfb，请手动安装${NC}"
            exit 1
        fi
        echo -e "${GREEN}✅ Xvfb安装完成${NC}"
    else
        echo -e "${GREEN}✅ Xvfb已安装${NC}"
    fi
    
    # 检查xvfb-run（可选，但如果可用会更方便）
    if ! command -v xvfb-run &> /dev/null; then
        echo -e "${YELLOW}💡 提示: 安装 xvfb-run 可以更简单地管理Xvfb（可选）${NC}"
        if command -v apt-get &> /dev/null; then
            echo -e "${CYAN}   安装命令: sudo apt-get install -y xvfb${NC}"
        elif command -v dnf &> /dev/null; then
            echo -e "${CYAN}   安装命令: sudo dnf install -y xorg-x11-server-Xvfb${NC}"
        fi
    fi
}

# 检查并处理Xvfb进程
check_and_start_xvfb() {
    echo -e "${YELLOW}🔍 检查Xvfb进程...${NC}"
    
    # 检查是否有Xvfb :99进程在运行
    XVFB_PID=$(pgrep -f "Xvfb :99" | head -n 1)
    
    if [ -n "$XVFB_PID" ]; then
        echo -e "${YELLOW}⚠️  检测到Xvfb :99已在运行 (PID: $XVFB_PID)${NC}"
        echo -e "${YELLOW}🔄 终止旧进程...${NC}"
        kill $XVFB_PID 2>/dev/null || true
        sleep 1
        
        # 确认进程是否已终止
        if pgrep -f "Xvfb :99" > /dev/null; then
            echo -e "${YELLOW}⚠️  强制终止...${NC}"
            kill -9 $XVFB_PID 2>/dev/null || true
            sleep 1
        fi
        echo -e "${GREEN}✅ 旧进程已终止${NC}"
    fi
    
    # 检查DISPLAY :99是否可用
    if [ -S "/tmp/.X11-unix/X99" ]; then
        echo -e "${YELLOW}⚠️  DISPLAY :99已被占用，清理中...${NC}"
        rm -f /tmp/.X11-unix/X99 2>/dev/null || true
    fi
    
    # 启动Xvfb :99
    echo -e "${YELLOW}🚀 启动Xvfb :99...${NC}"
    Xvfb :99 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset > /tmp/xvfb_99.log 2>&1 &
    sleep 2
    
    if pgrep -f "Xvfb :99" > /dev/null; then
        echo -e "${GREEN}✅ Xvfb :99启动成功${NC}"
        export DISPLAY=:99
    else
        echo -e "${RED}❌ Xvfb启动失败，请查看日志: /tmp/xvfb_99.log${NC}"
        exit 1
    fi
}

# 检查并创建虚拟环境
check_and_create_venv() {
    echo -e "${YELLOW}🔍 检查虚拟环境...${NC}"
    
    # 检查/opt/envs目录
    if [ ! -d "/opt/envs" ]; then
        echo -e "${YELLOW}📦 创建/opt/envs目录...${NC}"
        sudo mkdir -p /opt/envs
        sudo chmod -R 777 /opt/envs
    fi
    
    # 检查虚拟环境
    if [ ! -d "$VENV_PATH" ]; then
        echo -e "${YELLOW}📦 创建虚拟环境: $VENV_PATH${NC}"
        $PYTHON_CMD -m venv "$VENV_PATH"
        echo -e "${GREEN}✅ 虚拟环境创建完成${NC}"
    else
        echo -e "${GREEN}✅ 虚拟环境已存在: $VENV_PATH${NC}"
    fi
    
    # 激活虚拟环境
    if [ -f "$VENV_PATH/bin/activate" ]; then
        source "$VENV_PATH/bin/activate"
        echo -e "${GREEN}✅ 虚拟环境已激活${NC}"
    else
        echo -e "${RED}❌ 虚拟环境激活文件不存在${NC}"
        exit 1
    fi
}

# 安装Python依赖
install_dependencies() {
    echo -e "${YELLOW}📦 安装Python依赖...${NC}"
    
    # 确保在虚拟环境中
    if [ -z "$VIRTUAL_ENV" ]; then
        source "$VENV_PATH/bin/activate"
    fi
    
    # 升级pip
    pip install --upgrade pip -q
    
    # 检查requirements.txt
    if [ ! -f "$SCRIPT_DIR/requirements.txt" ]; then
        echo -e "${RED}❌ requirements.txt不存在: $SCRIPT_DIR/requirements.txt${NC}"
        exit 1
    fi
    
    # 安装依赖
    echo -e "${YELLOW}   正在安装依赖包（可能需要几分钟）...${NC}"
    pip install -r "$SCRIPT_DIR/requirements.txt" -q
    
    echo -e "${GREEN}✅ 依赖安装完成${NC}"
}

# 检查Playwright浏览器
check_playwright_browser() {
    echo -e "${YELLOW}🔍 检查Playwright浏览器...${NC}"
    
    # 设置PLAYWRIGHT_BROWSERS_PATH
    export PLAYWRIGHT_BROWSERS_PATH=/opt/playwright-browsers
    
    if [ ! -d "$PLAYWRIGHT_BROWSERS_PATH" ]; then
        echo -e "${YELLOW}📦 创建浏览器缓存目录...${NC}"
        sudo mkdir -p "$PLAYWRIGHT_BROWSERS_PATH"
        sudo chmod -R 777 "$PLAYWRIGHT_BROWSERS_PATH"
    fi
    
    # 检查浏览器是否已安装
    if [ -d "$PLAYWRIGHT_BROWSERS_PATH/chromium-1187" ] || \
       [ -d "$PLAYWRIGHT_BROWSERS_PATH/chromium-1179" ] || \
       [ -d "$PLAYWRIGHT_BROWSERS_PATH/chromium" ]; then
        echo -e "${GREEN}✅ Playwright浏览器已安装${NC}"
    else
        echo -e "${YELLOW}⚠️  Playwright浏览器未安装，正在安装（可能需要较长时间）...${NC}"
        if [ -n "$VIRTUAL_ENV" ]; then
            playwright install chromium
            echo -e "${GREEN}✅ 浏览器安装完成${NC}"
        else
            echo -e "${RED}❌ 虚拟环境未激活，无法安装浏览器${NC}"
            exit 1
        fi
    fi
}

# 直接运行Agent
run_agent() {
    echo -e "${CYAN}=========================================================${NC}"
    echo -e "${GREEN}🚀 启动Agent...${NC}"
    echo -e "${CYAN}=========================================================${NC}"
    echo ""
    
    # 确保在项目目录
    cd "$SCRIPT_DIR"
    
    # 再次确认main.py存在
    if [ ! -f "main.py" ]; then
        echo -e "${RED}❌ main.py 不存在于当前目录！${NC}"
        echo -e "${YELLOW}⚠️  当前目录: $(pwd)${NC}"
        exit 1
    fi
    
    # 确保虚拟环境已激活
    if [ -z "$VIRTUAL_ENV" ]; then
        source "$VENV_PATH/bin/activate"
    fi
    
    # 根据是否使用xvfb-run选择启动方式
    if [ "${USE_XVFB_RUN:-false}" = "true" ]; then
        # 使用xvfb-run启动（自动管理Xvfb，更可靠）
        echo -e "${YELLOW}📦 使用 xvfb-run 启动...${NC}"
        export PLAYWRIGHT_BROWSERS_PATH=/opt/playwright-browsers
        xvfb-run -a -s "-screen 0 1920x1080x24 -ac +extension GLX +render -noreset" python main.py
    else
        # 手动管理Xvfb的方式
        # 确保DISPLAY已设置
        if [ -z "$DISPLAY" ]; then
            export DISPLAY=:99
        fi
        export PLAYWRIGHT_BROWSERS_PATH=/opt/playwright-browsers
        python main.py
    fi
}

# 安装为系统服务
install_service() {
    check_root
    
    # 检查项目文件
    check_project_files
    
    echo -e "${CYAN}=========================================================${NC}"
    echo -e "${GREEN}📦 安装系统服务...${NC}"
    echo -e "${CYAN}=========================================================${NC}"
    
    # 检查服务是否已存在
    if systemctl list-unit-files | grep -q "^${SERVICE_NAME}.service"; then
        echo -e "${YELLOW}⚠️  服务已存在，先停止并卸载...${NC}"
        systemctl stop "$SERVICE_NAME" 2>/dev/null || true
        systemctl disable "$SERVICE_NAME" 2>/dev/null || true
        rm -f "$SERVICE_FILE"
        systemctl daemon-reload
    fi
    
    # 获取当前用户（如果通过sudo运行，获取SUDO_USER）
    SERVICE_USER="${SUDO_USER:-$USER}"
    if [ -z "$SERVICE_USER" ] || [ "$SERVICE_USER" = "root" ]; then
        # 如果没有SUDO_USER，尝试获取调用者的用户名
        SERVICE_USER=$(who am i | awk '{print $1}' || echo "$USER")
    fi
    
    # 创建启动脚本（用于服务）
    # 使用固定的路径，避免/tmp被清理
    SERVICE_START_SCRIPT="/opt/${SERVICE_NAME}_start.sh"
    
    # 检查是否使用xvfb-run
    if check_xvfb_run; then
        # 使用xvfb-run（更简单可靠）
        cat > "$SERVICE_START_SCRIPT" <<EOF
#!/bin/bash
# Agent服务启动脚本（由systemd调用，使用xvfb-run）

# 设置环境变量
export PLAYWRIGHT_BROWSERS_PATH=/opt/playwright-browsers

# 激活虚拟环境并运行Agent
source $VENV_PATH/bin/activate
cd $SCRIPT_DIR

# 使用xvfb-run启动（自动管理Xvfb）
exec xvfb-run -a -s "-screen 0 1920x1080x24 -ac +extension GLX +render -noreset" python main.py
EOF
        echo -e "${GREEN}✅ 使用 xvfb-run 模式（自动管理Xvfb）${NC}"
    else
        # 手动管理Xvfb
        cat > "$SERVICE_START_SCRIPT" <<EOF
#!/bin/bash
# Agent服务启动脚本（由systemd调用，手动管理Xvfb）

# 启动Xvfb（如果未运行）
if ! pgrep -f "Xvfb :99" > /dev/null; then
    Xvfb :99 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset > /tmp/xvfb_99.log 2>&1 &
    sleep 2
fi

# 设置环境变量
export DISPLAY=:99
export PLAYWRIGHT_BROWSERS_PATH=/opt/playwright-browsers

# 激活虚拟环境并运行Agent
source $VENV_PATH/bin/activate
cd $SCRIPT_DIR
exec python main.py
EOF
        echo -e "${YELLOW}⚠️  使用手动管理Xvfb模式（建议安装xvfb-run）${NC}"
    fi
    chmod +x "$SERVICE_START_SCRIPT"
    # 设置脚本所有者为服务用户
    chown "$SERVICE_USER:$SERVICE_USER" "$SERVICE_START_SCRIPT" 2>/dev/null || true
    
    # 创建服务文件
    echo -e "${YELLOW}📝 创建服务文件...${NC}"
    cat > "$SERVICE_FILE" <<EOF
[Unit]
Description=Goofish Agent Service
After=network.target

[Service]
Type=simple
User=$SERVICE_USER
WorkingDirectory=$SCRIPT_DIR
ExecStart=$SERVICE_START_SCRIPT
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF
    
    # 重新加载systemd
    systemctl daemon-reload
    
    # 启用服务
    systemctl enable "$SERVICE_NAME"
    
    echo -e "${GREEN}✅ 服务安装完成${NC}"
    echo -e "${CYAN}   服务名: ${SERVICE_NAME}${NC}"
    echo -e "${CYAN}   服务文件: ${SERVICE_FILE}${NC}"
    echo -e "${CYAN}   运行用户: ${SERVICE_USER}${NC}"
    echo ""
    echo -e "${YELLOW}📋 常用命令：${NC}"
    echo -e "${CYAN}   启动服务: sudo systemctl start ${SERVICE_NAME}${NC}"
    echo -e "${CYAN}   停止服务: sudo systemctl stop ${SERVICE_NAME}${NC}"
    echo -e "${CYAN}   查看状态: sudo systemctl status ${SERVICE_NAME}${NC}"
    echo -e "${CYAN}   查看日志: sudo journalctl -u ${SERVICE_NAME} -f${NC}"
    echo ""
    echo -e "${YELLOW}⚠️  注意：${NC}"
    echo -e "${YELLOW}   1. 服务已启用开机自启动${NC}"
    echo -e "${YELLOW}   2. Xvfb已集成到服务启动脚本中，会自动启动${NC}"
    echo -e "${YELLOW}   3. 服务启动时会自动检查并启动Xvfb :99${NC}"
}

# 卸载系统服务
uninstall_service() {
    check_root
    
    echo -e "${CYAN}=========================================================${NC}"
    echo -e "${GREEN}🗑️  卸载系统服务...${NC}"
    echo -e "${CYAN}=========================================================${NC}"
    
    # 停止服务
    if systemctl is-active --quiet "$SERVICE_NAME"; then
        echo -e "${YELLOW}🛑 停止服务...${NC}"
        systemctl stop "$SERVICE_NAME"
    fi
    
    # 禁用服务
    if systemctl is-enabled --quiet "$SERVICE_NAME" 2>/dev/null; then
        echo -e "${YELLOW}🚫 禁用服务...${NC}"
        systemctl disable "$SERVICE_NAME"
    fi
    
    # 删除服务文件
    if [ -f "$SERVICE_FILE" ]; then
        echo -e "${YELLOW}🗑️  删除服务文件...${NC}"
        rm -f "$SERVICE_FILE"
        systemctl daemon-reload
    fi
    
    # 删除启动脚本
    SERVICE_START_SCRIPT="/opt/${SERVICE_NAME}_start.sh"
    if [ -f "$SERVICE_START_SCRIPT" ]; then
        echo -e "${YELLOW}🗑️  删除启动脚本...${NC}"
        rm -f "$SERVICE_START_SCRIPT"
    fi
    
    echo -e "${GREEN}✅ 服务卸载完成${NC}"
}

# 检查项目文件是否存在
check_project_files() {
    echo -e "${YELLOW}🔍 检查项目文件...${NC}"
    
    if [ ! -f "$SCRIPT_DIR/main.py" ]; then
        echo -e "${RED}❌ 未找到 main.py 文件！${NC}"
        echo -e "${YELLOW}⚠️  当前目录: $SCRIPT_DIR${NC}"
        echo -e "${YELLOW}⚠️  请确保在项目根目录（包含 main.py 的目录）执行此脚本${NC}"
        echo ""
        echo -e "${CYAN}   正确的使用方式：${NC}"
        echo -e "${CYAN}   cd /home/project${NC}"
        echo -e "${CYAN}   ./start.sh${NC}"
        exit 1
    fi
    
    if [ ! -f "$SCRIPT_DIR/requirements.txt" ]; then
        echo -e "${YELLOW}⚠️  未找到 requirements.txt，依赖安装可能失败${NC}"
    fi
    
    echo -e "${GREEN}✅ 项目文件检查通过${NC}"
}

# 检查xvfb-run是否可用
check_xvfb_run() {
    if command -v xvfb-run &> /dev/null; then
        return 0
    else
        return 1
    fi
}

# 主函数
main() {
    # 首先检查项目文件
    check_project_files
    
    # 解析参数
    case "${1:-}" in
        -i|--install)
            install_service
            exit 0
            ;;
        -u|--uninstall)
            uninstall_service
            exit 0
            ;;
        -h|--help)
            show_help
            exit 0
            ;;
        "")
            # 无参数，直接运行
            ;;
        *)
            echo -e "${RED}❌ 未知参数: $1${NC}"
            show_help
            exit 1
            ;;
    esac
    
    # 环境检查
    check_python_version
    check_and_install_simple_deps
    
    # 检查是否使用xvfb-run（如果可用，优先使用，更简单可靠）
    if check_xvfb_run; then
        echo -e "${GREEN}✅ 检测到 xvfb-run，将使用它来启动（自动管理Xvfb）${NC}"
        USE_XVFB_RUN=true
    else
        echo -e "${YELLOW}⚠️  未检测到 xvfb-run，将手动管理 Xvfb 进程${NC}"
        USE_XVFB_RUN=false
        check_and_start_xvfb
    fi
    
    check_and_create_venv
    install_dependencies
    check_playwright_browser
    
    # 运行Agent
    run_agent
}

# 执行主函数
main "$@"

